package models

import (
	"order_srv/basic/config"
	"time"
)

// 导出任务表
type ExportTask struct {
	Id             uint32     `gorm:"column:id;type:int UNSIGNED;primaryKey;not null;" json:"id"`
	TaskId         string     `gorm:"column:task_id;type:varchar(255);comment:任务唯一标识;default:NULL;" json:"task_id"`              // 任务唯一标识
	UserId         uint32     `gorm:"column:user_id;type:int UNSIGNED;comment:操作人ID;not null;" json:"user_id"`                   // 操作人ID
	Status         uint8      `gorm:"column:status;type:tinyint UNSIGNED;comment:0-初始化 1-处理中 2-完成 3-失败;not null;" json:"status"` // 0-初始化 1-处理中 2-完成 3-失败
	TotalCount     uint32     `gorm:"column:total_count;type:int UNSIGNED;comment:总记录数;not null;" json:"total_count"`            // 总记录数
	Processed      uint32     `gorm:"column:processed;type:int UNSIGNED;comment:已处理数;not null;" json:"processed"`                // 已处理数
	FilePath       string     `gorm:"column:file_path;type:varchar(255);comment:导出文件路径;not null;" json:"file_path"`              // 导出文件路径
	ErrorMsg       string     `gorm:"column:error_msg;type:varchar(255);comment:错误信息;not null;" json:"error_msg"`                // 错误信息
	CreatedAt      time.Time  `gorm:"column:created_at;type:datetime;not null;default:CURRENT_TIMESTAMP;" json:"created_at"`
	UpdatedAt      time.Time  `gorm:"column:updated_at;type:datetime;not null;default:CURRENT_TIMESTAMP;" json:"updated_at"`
	TaskType       uint8      `gorm:"column:task_type;type:tinyint UNSIGNED;comment:类型;not null;" json:"task_type"`                         // 类型
	ExportFormat   string     `gorm:"column:export_format;type:varchar(20);comment:导出格式;not null;" json:"export_format"`                    // 导出格式
	IsEncrypted    bool       `gorm:"column:is_encrypted;type:tinyint(1);comment:是否加密;not null;" json:"is_encrypted"`                       // 是否加密
	EncryptionKey  string     `gorm:"column:encryption_key;type:varchar(255);comment:加密密钥;" json:"encryption_key"`                          // 加密密钥
	FileSize       int64      `gorm:"column:file_size;type:bigint;comment:文件大小;" json:"file_size"`                                          // 文件大小
	DownloadUrl    string     `gorm:"column:download_url;type:varchar(500);comment:下载链接;" json:"download_url"`                              // 下载链接
	CompletedAt    *time.Time `gorm:"column:completed_at;type:datetime;comment:完成时间;" json:"completed_at"`                                  // 完成时间
	StartTime      time.Time  `gorm:"column:start_time;type:datetime;comment:开始时间;" json:"start_time"`                                      // 开始时间
	EndTime        time.Time  `gorm:"column:end_time;type:datetime;comment:结束时间;" json:"end_time"`                                          // 结束时间
	FilterParams   string     `gorm:"column:filter_params;type:text;comment:过滤参数;" json:"filter_params"`                                    // 过滤参数JSON
	Progress       float32    `gorm:"column:progress;type:decimal(5,2);comment:进度百分比;" json:"progress"`                                     // 进度百分比
	Priority       uint8      `gorm:"column:priority;type:tinyint UNSIGNED;comment:任务优先级 1-低 2-普通 3-高;not null;default:2;" json:"priority"` // 任务优先级
	MaxRecords     uint32     `gorm:"column:max_records;type:int UNSIGNED;comment:最大导出记录数;not null;default:0;" json:"max_records"`          // 最大导出记录数
	IncludeSummary bool       `gorm:"column:include_summary;type:tinyint(1);comment:是否包含汇总数据;not null;default:1;" json:"include_summary"`   // 是否包含汇总数据
	CurrentStep    string     `gorm:"column:current_step;type:varchar(100);comment:当前步骤;" json:"current_step"`                              // 当前步骤
	EstimatedTime  string     `gorm:"column:estimated_time;type:varchar(50);comment:预计剩余时间;" json:"estimated_time"`                         // 预计剩余时间
	RetryCount     uint8      `gorm:"column:retry_count;type:tinyint UNSIGNED;comment:重试次数;not null;default:0;" json:"retry_count"`         // 重试次数
	MaxRetries     uint8      `gorm:"column:max_retries;type:tinyint UNSIGNED;comment:最大重试次数;not null;default:3;" json:"max_retries"`       // 最大重试次数
	LastError      string     `gorm:"column:last_error;type:text;comment:最后错误信息;" json:"last_error"`                                        // 最后错误信息
	TaskData       string     `gorm:"column:task_data;type:text;comment:任务数据;" json:"task_data"`                                            // 任务数据
}

// 创建任务
func (e *ExportTask) Create() error {
	return config.DB.Create(e).Error
}

// 获取任务进度
func (e *ExportTask) GetExportProgress(taskId string, userId uint32) error {
	return config.DB.Where("task_id = ? AND user_id = ?", taskId, userId).First(&e).Error
}

// 更新任务状态和文件路径
func (e *ExportTask) UpdateStatus(status uint8, msg string) error {
	updates := map[string]interface{}{
		"status":     status,
		"error_msg":  msg,
		"updated_at": time.Now(),
	}
	// 如果FilePath不为空，也更新FilePath
	if e.FilePath != "" {
		updates["file_path"] = e.FilePath
	}
	// 如果状态为完成，设置完成时间
	if status == 2 {
		now := time.Now()
		updates["completed_at"] = &now
	}
	return config.DB.Model(e).Updates(updates).Error
}

// 更新任务状态和当前步骤
func (e *ExportTask) UpdateStatusWithStep(status uint8, msg string, step string) error {
	updates := map[string]interface{}{
		"status":       status,
		"error_msg":    msg,
		"current_step": step,
		"updated_at":   time.Now(),
	}
	// 如果状态为完成，设置完成时间
	if status == 2 {
		now := time.Now()
		updates["completed_at"] = &now
	}
	return config.DB.Model(e).Updates(updates).Error
}

// 更新重试信息
func (e *ExportTask) UpdateRetryInfo(retryCount uint8, lastError string) error {
	return config.DB.Model(e).Updates(map[string]interface{}{
		"retry_count": retryCount,
		"last_error":  lastError,
		"updated_at":  time.Now(),
	}).Error
}

// 更新预计时间
func (e *ExportTask) UpdateEstimatedTime(estimatedTime string) error {
	return config.DB.Model(e).Updates(map[string]interface{}{
		"estimated_time": estimatedTime,
		"updated_at":     time.Now(),
	}).Error
}

// 更新进度
func (e *ExportTask) UpdateProgress(processed int64) error {
	progress := float32(0)
	if e.TotalCount > 0 {
		progress = float32(processed) / float32(e.TotalCount) * 100
	}

	return config.DB.Model(e).Updates(map[string]interface{}{
		"processed":  processed,
		"progress":   progress,
		"updated_at": time.Now(),
	}).Error
}

// 更新文件信息
func (e *ExportTask) UpdateFileInfo(filePath string, fileSize int64, downloadUrl string) error {
	now := time.Now()
	return config.DB.Model(e).Updates(map[string]interface{}{
		"file_path":    filePath,
		"file_size":    fileSize,
		"download_url": downloadUrl,
		"completed_at": &now,
		"updated_at":   now,
	}).Error
}

// 更新加密信息
func (e *ExportTask) UpdateEncryptionInfo(isEncrypted bool, encryptionKey string) error {
	return config.DB.Model(e).Updates(map[string]interface{}{
		"is_encrypted":   isEncrypted,
		"encryption_key": encryptionKey,
		"updated_at":     time.Now(),
	}).Error
}

// 获取导出任务列表
func GetExportTaskList(userId uint32, page, pageSize int, status uint32, startDate, endDate string) ([]*ExportTask, int32, error) {
	var tasks []*ExportTask
	var total int64

	query := config.DB.Model(&ExportTask{}).Where("user_id = ?", userId)

	if status > 0 {
		query = query.Where("status = ?", status)
	}

	if startDate != "" {
		query = query.Where("created_at >= ?", startDate)
	}

	if endDate != "" {
		query = query.Where("created_at <= ?", endDate)
	}

	// 获取总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 分页查询
	offset := (page - 1) * pageSize
	if err := query.Order("created_at DESC").Limit(pageSize).Offset(offset).Find(&tasks).Error; err != nil {
		return nil, 0, err
	}

	return tasks, int32(total), nil
}

// 根据任务ID获取导出任务
func GetExportTaskByTaskId(taskId string) (*ExportTask, error) {
	var task ExportTask
	err := config.DB.Where("task_id = ?", taskId).First(&task).Error
	return &task, err
}

// 删除导出任务
func DeleteExportTask(taskId string, userId uint32) error {
	return config.DB.Where("task_id = ? AND user_id = ?", taskId, userId).Delete(&ExportTask{}).Error
}

// 清理过期任务
func CleanExpiredTasks(days int) error {
	expiredTime := time.Now().AddDate(0, 0, -days)
	return config.DB.Where("created_at < ? AND status IN (2, 3)", expiredTime).Delete(&ExportTask{}).Error
}

// 获取任务统计信息
func GetTaskStatistics(userId uint32, startDate, endDate string) (map[string]interface{}, error) {
	var stats map[string]interface{} = make(map[string]interface{})

	query := config.DB.Model(&ExportTask{}).Where("user_id = ?", userId)

	if startDate != "" {
		query = query.Where("created_at >= ?", startDate)
	}
	if endDate != "" {
		query = query.Where("created_at <= ?", endDate)
	}

	// 总任务数
	var totalTasks int64
	if err := query.Count(&totalTasks).Error; err != nil {
		return nil, err
	}
	stats["total_tasks"] = totalTasks

	// 各状态任务数
	var statusCounts []struct {
		Status uint8 `json:"status"`
		Count  int64 `json:"count"`
	}
	if err := query.Select("status, count(*) as count").Group("status").Scan(&statusCounts).Error; err != nil {
		return nil, err
	}

	statusMap := make(map[uint8]int64)
	for _, sc := range statusCounts {
		statusMap[sc.Status] = sc.Count
	}
	stats["status_counts"] = statusMap

	// 平均处理时间
	var avgProcessingTime float64
	if err := query.Where("status = 2 AND completed_at IS NOT NULL").
		Select("AVG(TIMESTAMPDIFF(SECOND, created_at, completed_at)) as avg_time").
		Scan(&avgProcessingTime).Error; err != nil {
		return nil, err
	}
	stats["avg_processing_time"] = avgProcessingTime

	return stats, nil
}

// 获取失败任务列表
func GetFailedTasks(userId uint32, limit int) ([]*ExportTask, error) {
	var tasks []*ExportTask
	query := config.DB.Where("user_id = ? AND status = 3", userId).
		Order("created_at DESC")

	if limit > 0 {
		query = query.Limit(limit)
	}

	err := query.Find(&tasks).Error
	return tasks, err
}

// 重试失败任务
func RetryFailedTask(taskId string, userId uint32) error {
	return config.DB.Model(&ExportTask{}).
		Where("task_id = ? AND user_id = ? AND status = 3", taskId, userId).
		Updates(map[string]interface{}{
			"status":      1, // 重新设置为处理中
			"retry_count": config.DB.Raw("retry_count + 1"),
			"updated_at":  time.Now(),
		}).Error
}
